Aufgabe
=======
Schreibe die Schleife in hatErschlagen() so um, dass sie 
als for-schleife funktioniert (d.h. die Laufinstruktion wird
*nach* den Arbeitsinstruktionen ausgeführt).

Hinweis: es ändert sich die *Arbeitsinstruktion*

Hinweis: Ändert zunächst die Arbeitsinstruktion so, dass
         im ersten Schleifendurchlauf, statt der null aus dem
         ersten Listenelement schon die Hydra aus dem
         nachfolgenden Listenelement aufgezeichnet wird.

  weiter.biest -> null
  ????         -> "Hydra"

  kette.biest <=> this.kette.biest -> "Hydra"


Aufgabe
=======
Implementiere biestNr( n )

 - übergeben wird eine Position in der Liste "n"
 - die Liste soll um "n" Positionen durchlaufen werden
 - das "biest" an der n-ten Stelle wird zurück gegeben

Hinweis: die Funktion braucht mindestens eine Laufvariable
         "weiter"

Hinweis: die Zählung erfolgt nicht bis zum Ende der Liste
         (weiter.kette != null), sondern ist abhängig von `n`

[x] Teil 1: wie wird die Laufvariable deklariert?

[x] Teil 2: wie schaffen wir es, genau `n` Elemente weiter
            zu laufen
    - Zählbedingung abhängig von `n`
    - Zählinstruktion verändert `n`
    - Arbeitsanweisung verändert `weiter`

-----------------------------------------------------------
[ ] Teil 3: Die `biest`-Property des so abgezählten Elements
            soll zurückgegeben werden.
-------------------------------------------------------------

Was ist das Schlüsselwort um einen Wert aus einer Funktion
zurückzugeben? -> return

Wie sieht eine Schleife aus, die 4x "Hallo Welt!" ausgibt?

Wie sieht eine Schleife aus, die `n` mal "Hallo Welt!" ausgibt?
  - wenn `n` auf 42 gesetzt ist, soll 42 mal "Hallo Welt!" da stehen
  - wenn `n` 23 ist, soll 23 mal "Hallo Welt!" da stehen
  - usw...

Wie sieht eine Schleife aus, die `n` mal die Listenvariable
`weiter` weiterführt (auf das nachfolgende Listenelement setzt)?

  Die Laufinstruktion in der leeren Schleife in `erschlage()`
  führt dort die Listenvariable `weiter` weiter
  weiter = weiter.kette;

Wie sieht eine Schleife aus, die die Listenvariable `weiter` 4 mal
weiterführt (also auf das nachfolgende Listenelement setzt)?
Wie sieht eine Schleife aus, die 4 mal |"Hallo Welt!" ausgibt?
Wie sieht eine Schleife aus, die 4 mal |die Listenvariable `weiter` weiterführt?

  Wie sieht die Instruktion aus, mit der man "Hallo Welt!" ausgibt
  Wie sieht die Instruktion aus, mit der man die Listenvariable `weiter` weiterführt?


Instruktion, um "Hallo Welt!" auszugeben:

  System.out.println("Hallo Welt!");


Instruktion um die Listenvariable weiterzuführen:

  weiter = weiter.kette;

  
Schleife, um 4 mal "Hallo Welt!" auszugeben

  for ( i = 0; i < 4; i++) {
    System.out.println("Hallo Welt!");
  }

Wie ist die Schleife, um die Listenvariable 4 mal weiterzuführen?

  for (int i = 0; i < 4; i++) {
    weiter = weiter.kette;
  }   


Wie ist die Schleife, um die Listenvariable `n` mal weiterzuführen?


Aufgabe:
========
In der Methode biestNr() sollen unsinnige Anfragen abgefangen
werden. D.H. folgende assertions sollen Funktionieren:

    assert(hercules.biestNr(0) == null);
    assert(hercules.biestNr(-23) == null);
    assert(hercules.biestNr(15) == null);











Frage 1: Was ist die aktuelle Rückgabe der Methode, wenn
         n == 0 ist?